package com.example.task.timer.case2;

import com.example.task.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.concurrent.*;

/**
 * @author sunny
 * @desc 执行任务   case2 采用定义线程池的方案  在采用方案2的情况下 默认异步线程池 已经关闭
 */
@Component
@Slf4j
public class TaskExecute2 {

    @Resource
    private OrderService orderService;

    /**
     * 任务发起
     * 需求两个任务 从同一个定时任务触发  该方法是两个方法的总入口
     *
     *  定时每日0点开始扫描订单表，对于前一天已完成的订单，将订单金额统计到上一天的营业额。
     *  对于超过24小时未支付的订单，做自动取消并通知给用户的功能。（通知功能可以使用伪代码）
     */
    @Scheduled(cron = "0 0 0 * * ?") // 每天的0点执行
    public void execute(){
        // 使用固定线程池
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        // 自定义线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                10,
                20,
                0L,
                TimeUnit.MILLISECONDS,
//                new LinkedBlockingQueue<Runnable>(300),
//                new ArrayBlockingQueue(200),
                new PriorityBlockingQueue(),
                // 线程工厂 可以自定义
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );

        /////////////////////////////////////// 根据不同的场景 使用不同的 线程池

        executorService.submit(() -> {
            try {
                // 查询前一天已完成的订单
                orderService.findPayOrderByTime();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        executorService.submit(() -> {
            try {
                // 查询超过24小时未支付的订单的订单
                orderService.findUnpayOrderByTime();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });


        // 关闭线程池
        executorService.shutdown();

    }



    public static void main(String[] args) {
        Thread a = new Thread(()->{
            System.out.println("A");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread b = new Thread(()->{
            System.out.println("B start");
            try {
                a.join();
                Thread.sleep(1000);
                System.out.println("B end");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        b.start();
        a.start();
    }

}
